Relational database recovery

ABSTRACT

A database recovery and index rebuilding method involves reading data pages for a database to be recovered as recovery bases; retrieving all log records from stored post-backup updates and sorting the retrieved log records; as the data pages to be recovered are read, applying the sorted log records to their respective data pages; as the applying completes for individual data pages, extracting and sorting index keys from the individual data pages for which the applying is complete, until all index keys have been extracted from all individual data pages and sorted; on an individual recovered page basis, writing the recovered individual data pages into the database; and when all index keys have been extracted and sorted from all of the recovered individual data pages, rebuilding indexes of the database using the sorted index keys and writing the rebuilt indexes to the non-transitory storage.

CROSS REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No. 15/362,857, which is a continuation of U.S. patent application Ser. No. 15/184,038 (now U.S. Pat. No. 9,558,077), the entireties of which are incorporated herein by reference.

FIELD OF THE INVENTION

This disclosure relates generally to computers and, more particularly, to recovery of relational databases.

BACKGROUND

In relational database management systems (DBMSs), when a database must be recovered due to some problem or issue, the elapsed time for data recovery followed by the rebuild of indexes can be very long for large amounts of data, in some cases, many hours. During this recovery time period, the data from that database is completely unavailable and processing capability is reduced or eliminated for the processor(s) involved in the recovery process. Service Level Agreements (SLA) applicable in the banking, financial, retail, insurance and IT services industries, which define the maximum amount of time for data recovery, are extremely aggressive due to the nature of those businesses. Prolonged outages can lead to financial penalties and loss of business both for the database owner and the party responsible for SLA compliance (if different from the database owner).

Current database rebuilding processes are highly sequential and uses a buffer pool (also called a buffer cache), which is a portion of a main memory space allocated by the database manager to cache table and index data from the disk containing the database in order to reduce the amount of database input/output (I/O) and database data and index access time.

Thus, there is an ongoing technological need for an improvement to the way databases operate with respect to rebuilding the database when required.

SUMMARY

One aspect of the present invention described and claimed herein involves a method of recovering database data and rebuilding database indexes. The method involves a) reading data pages for a database to be recovered, from image copies stored in non-transitory storage as recovery bases, into objects in memory; b) concurrently with step “a)” retrieving, into memory, all log records from stored post-backup updates that are applicable to the data pages to be recovered and sorting the retrieved log records by object, data page number and timestamp; c) as the data pages to be recovered are read into the objects in “a)”, applying the sorted log records to their respective data pages, in timestamp order, until all of the sorted log records have been applied to all of their respective data pages; d) as the applying of the respective sorted log records to the data pages in “c)” completes for individual data pages, and concurrently with the performing of “c)” with respect to specific data pages for which the applying is not yet complete, extracting and sorting index keys from the individual data pages for which the applying is complete, until all the index keys have been extracted from all the individual data pages and sorted; e) concurrently with “d)”, on an individual recovered page basis, writing the recovered individual data pages, for which the extraction of the index keys is complete, into the database in the non-transitory storage; and f) when all index keys have been extracted and sorted from all of the recovered individual data pages, rebuilding indexes of the database using the sorted index keys and writing the rebuilt indexes to the non-transitory storage without regard to whether “e)” is complete.

Our invention is a significant improvement to the functioning of a computer specifically tasked with rebuilding a database, and only has utility with respect to rebuilding of databases. More particularly, our invention provides a specific solution to a significant problem with the processes by which database rebuilding software operates in that it improves the way the computer stores and retrieves data necessary for rebuilding a computer database to provide a significant improvement in the time necessary to rebuild a large database relative to current approaches.

Indeed, our invention represents a unique and specific improvement to the process used to rebuild such databases, more particularly, an improvement to the logical structure and processes by which databases are be rebuilt after some problem or issue has occurred.

Various technical advantages and benefits flow from our invention, for example, it significantly improves the efficiency of a computer's ability to perform database recovery relative to current database recovery processes, thereby freeing up that computer's processing capability for other tasks, it reduces the number of read I/Os and random write I/Os typically involved with database rebuild, and consequently, it reduces the time needed to rebuild a large database so that the rebuilt database will be operational and available much faster than it would using conventional data recovery processes, thereby improving SLA compliance.

The foregoing and following outlines rather generally the features and technical advantages of one or more embodiments of this disclosure in order that the following detailed description may be better understood. Additional features and advantages of this disclosure will be described hereinafter, which may form the subject of the claims of this application.

BRIEF DESCRIPTION OF THE DRAWINGS

This disclosure is further described in the detailed description that follows, with reference to the drawings, in which:

FIG. 1 illustrates, in simplified form, an overview of a computer system made up of at least a computer and associated non-transitory storage incorporating our relational database recovery invention; and

FIG. 2 which is a simplified flowchart of the functional steps that result from the processor(s) executing the program instructions relating to database recovery as described herein.

DETAILED DESCRIPTION

This disclosure provides a technical solution to address the aforementioned problems inherent with relational database recovery.

FIG. 1 illustrates, in simplified form, an overview of a computer system 100 made up of at least a computer 102 and associated storage 104 incorporating our relational database recovery invention.

As shown, the computer 100 may be as simple as a uni-processor computer, a more complex computer, for example, a single server, or, for example, a highly complex distributed computer. In general, the computer 102 is made up of at least one, and typically more, processor(s) 106 and memory 108 that the processor(s) 106 can read from and write to.

The storage 104 can be written to and read from, and stores data, data-containing structures, and program instructions in a non-transitory manner, for example, such as non-transient solid state memory, a magnetic hard drive, a CD or DVD, a tape drive, or an analogous or equivalent storage medium type would.

The storage 104, which may be physically a single device or multiple storage devices, has stored within it at least program instructions 110 that can be accessed and executed by the processor(s) 106 to, at least, effect the database recovery operations as described herein, and a relational database system 112. The database system 112 is made up of the database 114 itself, which can be localized or distributed, a set of image copies 116, which are backups of data pages 120 that can be used as a basis for recovery in the event of an issue or problem with the database 114, for example, data corruption or a crash, and a set of post-backup updates 118, which contain log records 122 of changes to the database since the last image copy 116 was made. The log records 122 each have associated with them an identifier 124 of an object 126 to which each applies, an identifier 128 of a data page 120 to which each applies, and a timestamp 130 for when that log record 122 was made.

In general, the referenced components of the database system 112, i.e., the database 114, image copies 116, and post-backup updates (e.g., log records and their contents) are all common to current database systems (although they may be known by different names or be arranged slightly differently) and, thus are conventional so that further details of their makeup need not be described since our relational database-related invention does not hinge upon the makeup of those components, but rather how they are used. Thus, persons of ordinary skill in the art will be able to readily apply the teachings of the instant disclosure even is there is some variation for particular relational database systems.

Before describing our process, for contrast, the current database recovery process for DB2 will briefly be described.

The current DB2 database recovery process starts by restoring the database data pages. The data pages from the image copies are restored via a buffer pool. Note here that the data pages in the buffer pool can be stolen before any of the log record application process begins. Next, the log datasets are read sequentially, in small portions, and only those small portions of the log records are sorted, by object, data page number, and timestamp. The updated data pages are then prefetched from the database into the buffer pool and the log records are applied in skip sequential order to the data pages in the buffer pool. Then, asynchronously, the DB2 buffer manager uses its ordinary deferred write processing to asynchronously write the pages to disk. Notably, these asynchronous write I/Os are random, making them very slow. Consequently, the physical disks involved in the process become very busy, which can further slow down the random read I/O and also fill the buffer pool with changed pages. If no buffers are available to read a page into, the read becomes gated behind the write I/O. After applying all of the updates for this small portion of log records, the process repeats for the next portion of log records. Thus, there are excessive read I/Os during the log record application because only small portions of the log records are sorted and applied iteratively. Moreover, for each iteration, the same pages may need to be repeatedly processed, which requires re-reading those pages back into the buffer pool over and over for log record application. There are also excessive I/Os during the rebuild of the database indexes because all of the data pages must be sequentially brought into the buffer pool so that the keys can be extracted.

Having described the physical makeup of a computer system 100 as it would implement the teachings herein and provided an example of how current database recovery occurs in DB2, the inventive relational database recovery process will now be described with continuing reference to FIG. 1, and with reference to FIG. 2 which is a simplified flowchart 200 for the functional steps that would result from the processor(s) 106 executing the program instructions 110 relating to database recovery as described herein. Note here that, in FIG. 2, steps that are shown alongside each other can occur, in whole or part, concurrently in parallel.

The process begins at the point where it is determined that a database 114 needs to be rebuilt. When that happens, a command or set of instructions are sent to the computer system 100 to trigger the database rebuild function. As a result, the appropriate program instructions 110 are retrieved from the storage 104 and executed by the processor(s) 106 to cause the following steps to occur.

The processor(s) 106 will access the image copies 116 from the storage 104 for use as recovery bases (Step 202 a) (referred to herein as “image copy recovery bases”). The processor(s) 106 will also access a range of the post-backup updates 118 stored in the storage 104 needed to be re-applied to the image copy recovery bases 116 in order to reconstruct the database 114 (Step 202 b). Note that these steps will generally be performed in parallel, although either could start or complete before the other such that they only partially overlap in time.

Next, without regard to how far along Step 202 b is, the processor(s) 106 will read the data pages 120 to be recovered from the image copies 116 into objects 126 in memory 108 (Step 204 a). Concurrently with this step, the processor(s) 106 will retrieve into memory 108 all the log records 122 from the post-backup updates 118 that are applicable to the data pages 120 to be recovered and sort the retrieved log records 122 by object 126 identified by the indicator 124, data page number 128 and timestamp 130 (Step 204 b).

Now, as the data pages 120 to be recovered are read into the objects 126, the sorted log records 122 for those data pages 120 are applied to the respective data pages 120 in timestamp order, from oldest to newest. This occurs until all of the data pages 120 have been read in and all the applicable sorted log records 122 have been applied (Step 206).

Now, on an individual data page 120 basis and concurrently with Step 206 proceeding, once an individual data page 120 has had all of its applicable log records 122 applied, the processor(s) 106 will begin extracting and sorting index keys 132 from the individual data pages 120 (Step 208), with Step 208 continuing until all of the data pages 120 have had their log records 122 applied and all of the index keys 132 have been extracted 134 from each data page 120 and sorted 136.

As Step 208 is proceeding with respect to the individual data pages 120, once all the index keys 132 have been extracted from any given data page 120, that data page 120 is written into the database 114 in storage 104 (Step 210) without regard to what other prior steps are in process or remain to be completed.

When all of the index keys 132 have been extracted 134 and sorted 136 for all of the recovered data pages 120, a rebuild of the database indexes, using the sorted index keys 136, is initiated (Step 212 a).

Finally, once the database indexes have been rebuilt, using the sorted index keys 136, the rebuilt indexes 138 are written into the storage 104 without regard to whether or not the writing of all the recovered data pages 120 into the database 114 has completed.

As should now be appreciated, the specific ordering and steps involved in our approach involves a high degree of parallelism and concurrency as compared with conventional approaches that predominantly requires sequential steps where most, if not all, individual steps must be complete before the next step in the process can proceed. As a result, the time for recovery of a large database can be significantly reduced. Moreover, our approach dramatically reduces the number of asynchronous read I/Os and write I/Os relative to, for example, the current database recovery process used in DB2.

In addition, it should further be appreciated that, with our inventive approach, only the relevant log records 122 are read and sorted. Advantageously, by doing so at recovery time, it is already known exactly which objects need to be recovered. Still further, by applying all of the log records applicable to a data page at one time eliminates the need for re-reading the same data pages over and over. Likewise, the extraction of the index keys 132 from each individual data page 120 right after application of all the log records 122 for it has completed allows the rebuilding of the indexes to occur in parallel with the data recovery. This approach is a marked improvement over current approaches that either create partially sorted log files in real time that must be collected and merged into a single stream during recovery using all of the log files, even if not all of the objects need to be recovered, or buffer some of the needed log records in groups and sort those groups.

Thus, as should now be appreciated, our inventive and highly unconventional approach represents a significant improvement to computers tasked with recovering relational databases and to the relational database recovery process itself.

Having described and illustrated the principles of this application by reference to one or more example embodiments, it should be apparent that the embodiment(s) may be modified in arrangement and detail without departing from the principles disclosed herein and that it is intended that the application be construed as including all such modifications and variations insofar as they come within the spirit and scope of the subject matter disclosed. 

What is claimed is:
 1. A method of recovering database data and rebuilding database indexes, the method comprising: a) reading data pages for a database to be recovered, from image copies stored in non-transitory storage as recovery bases, into objects in memory; b) concurrently with step “a)” retrieving, into memory, all log records from stored post-backup updates that are applicable to the data pages to be recovered and sorting the retrieved log records by object, data page number and timestamp; c) as the data pages to be recovered are read into the objects in “a)”, applying the sorted log records to their respective data pages, in timestamp order, until all of the sorted log records have been applied to all of their respective data pages; d) as the applying of the respective sorted log records to the data pages in “c)” completes for individual data pages, and concurrently with the performing of “c)” with respect to specific data pages for which the applying is not yet complete, extracting and sorting index keys from the individual data pages for which the applying is complete, until all the index keys have been extracted from all the individual data pages and sorted; e) concurrently with “d)”, on an individual recovered page basis, writing the recovered individual data pages, for which the extraction of the index keys is complete, into the database in the non-transitory storage; and f) when all index keys have been extracted and sorted from all of the recovered individual data pages, rebuilding indexes of the database using the sorted index keys and writing the rebuilt indexes to the non-transitory storage without regard to whether “e)” is complete. 